home *** CD-ROM | disk | FTP | other *** search
/ PC World 2007 June / PCWorld_2007-06_cd.bin / v cisle / tclock / tclocklight-040702-3.exe / source / timer / timer.c < prev   
C/C++ Source or Header  |  2004-09-07  |  6KB  |  285 lines
  1. /*-------------------------------------------------------------
  2.   timer.c : executing timers
  3.   (C) Kazuto Sato 1997-2003
  4.   For the license, please read readme.txt.
  5.   
  6.   Written by Kazubon, Nanashi-san
  7. ---------------------------------------------------------------*/
  8.  
  9. #include "tctimer.h"
  10.  
  11. /* Globals */
  12. void TimerStart(PTIMERSTRUCT pTS);
  13. void ClearTimer(void);
  14. BOOL IsTimerRunning(void);
  15. void OnTimerTimer(HWND hDlg);
  16. void OnRequestMenu(HWND hDlg, BOOL bClear);
  17. void OnStopTimer(HWND hDlg, int id);
  18.  
  19. /* Statics */
  20.  
  21. static void DoTimer(HWND hwnd, int index);
  22. static void DeleteRunningTimer(HWND hwnd, int index);
  23.  
  24. static PTIMERSTRUCT m_pTimerRun = NULL;
  25. static int m_numTimerRun = 0;
  26. static int m_idCurrent = 1;
  27.  
  28. /*-------------------------------------------
  29.   add a timer to m_pTimerRun and start
  30. ---------------------------------------------*/
  31. void TimerStart(PTIMERSTRUCT pTS)
  32. {
  33.     PTIMERSTRUCT pNew;
  34.     
  35.     pTS->interval = pTS->minute * 60 + pTS->second;
  36.     pTS->tickonstart = GetTickCount();
  37.     pTS->id = m_idCurrent++;
  38.     
  39.     pNew = AddTimerStruct(m_pTimerRun, m_numTimerRun, pTS);
  40.     m_numTimerRun++;
  41.     if(m_pTimerRun) free(m_pTimerRun);
  42.     m_pTimerRun = pNew;
  43. }
  44.  
  45. /*-------------------------------------------
  46.   clear all timers
  47. ---------------------------------------------*/
  48. void ClearTimer(void)
  49. {
  50.     free(m_pTimerRun);
  51.     m_pTimerRun = NULL;
  52.     m_numTimerRun = 0;
  53. }
  54.  
  55. /*-------------------------------------------
  56.   timer is running ?
  57. ---------------------------------------------*/
  58. BOOL IsTimerRunning(void)
  59. {
  60.     return (m_pTimerRun != NULL);
  61. }
  62.  
  63. /*-------------------------------------------
  64.   WM_TIMER message
  65. ---------------------------------------------*/
  66. void OnTimerTimer(HWND hwnd)
  67. {
  68.     DWORD tick;
  69.     int i, indexDo;
  70.     int nCopyData;
  71.     char s[20];
  72.     wchar_t ws[20];
  73.     
  74.     if(!m_pTimerRun) return;
  75.     
  76.     tick = GetTickCount();
  77.     indexDo = -1;
  78.     for(i = 0; i < m_numTimerRun; i++)
  79.     {
  80.         PTIMERSTRUCT pTS = m_pTimerRun + i;
  81.         
  82.         if(pTS->bDisp)
  83.         {
  84.             int remaining =
  85.                 pTS->interval - (tick - pTS->tickonstart)/1000 - 1;
  86.             if(remaining >= 0)
  87.             {
  88.                 if(pTS->nDispType == 0)
  89.                     nCopyData = COPYDATA_DISP1;
  90.                 else if(pTS->nDispType == 2)
  91.                     nCopyData = COPYDATA_USTR0 + pTS->nUserStr;
  92.                 else
  93.                     nCopyData = COPYDATA_CAT1;
  94.                 wsprintf(s, "[%02d:%02d]", remaining/60, remaining%60);
  95.                 
  96.                 MultiByteToWideChar(CP_ACP, 0, s, -1, ws, 19);
  97.                 SendStringToOtherW(g_hwndClock, hwnd, ws, nCopyData);
  98.             }
  99.         }
  100.         
  101.         if(indexDo < 0 && tick - pTS->tickonstart > pTS->interval * 1000)
  102.             indexDo = i;
  103.     }
  104.     
  105.     if(indexDo >= 0)
  106.         DoTimer(hwnd, indexDo);
  107. }
  108.  
  109. /*-------------------------------------------
  110.   add item to tcmenu*.txt
  111. ---------------------------------------------*/
  112. void OnRequestMenu(HWND hwnd, BOOL bClear)
  113. {
  114.     char tcmenutxt[MAX_PATH];
  115.     WIN32_FIND_DATA fd;
  116.     HANDLE hfind;
  117.     HFILE hf;
  118.     int size;
  119.     char *buf;
  120.     const char *p, *np;
  121.     static BOOL bWrite = FALSE;
  122.     
  123.     if(!bClear && m_pTimerRun == NULL) return;
  124.     
  125.     if(bClear && !bWrite) return;
  126.     
  127.     // ../common/tclang.c
  128.     FindFileWithLangCode(tcmenutxt, GetUserDefaultLangID(), TCMENUTXT);
  129.     
  130.     hfind = FindFirstFile(tcmenutxt, &fd);
  131.     if(hfind == INVALID_HANDLE_VALUE) return;
  132.     
  133.     FindClose(hfind);
  134.     size = (int)fd.nFileSizeLow;
  135.     buf = malloc(size+1);
  136.     if(!buf) return;
  137.     
  138.     hf = _lopen(tcmenutxt, OF_READWRITE);
  139.     if(hf == HFILE_ERROR) { free(buf); return; }
  140.     _lread(hf, buf, size);
  141.     *(buf + size) = 0;
  142.     
  143.     _llseek(hf, 0, 0);
  144.     
  145.     p = buf;
  146.     while(*p)
  147.     {
  148.         if(strncmp(p, "#Timer Begin", 12) == 0)
  149.         {
  150.             int i;
  151.             DWORD tick;
  152.             char s[160];
  153.             
  154.             np = nextline(p);
  155.             _lwrite(hf, p, np - p);
  156.             p = np;
  157.             
  158.             tick = GetTickCount();
  159.             
  160.             for(i = 0; i < m_numTimerRun && m_pTimerRun; i++)
  161.             {
  162.                 PTIMERSTRUCT pTS = m_pTimerRun + i;
  163.                 int remaining =
  164.                     pTS->interval - (tick - pTS->tickonstart)/1000 - 1;
  165.                 
  166.                 wsprintf(s, "\"%s %s %02d:%02d\" post %s %d 0 %d\r\n",
  167.                     MyString(IDS_STOP, "Stop"),
  168.                     pTS->name, remaining/60, remaining%60,
  169.                     CLASS_TCLOCKTIMER, TIMERM_STOP, pTS->id);
  170.                 _lwrite(hf, s, strlen(s));
  171.             }
  172.             
  173.             while(*p)
  174.             {
  175.                 if(strncmp(p, "#Timer End", 10) == 0)
  176.                     break;
  177.                 p = nextline(p);
  178.             }
  179.         }
  180.         else
  181.         {
  182.             np = nextline(p);
  183.             _lwrite(hf, p, np - p);
  184.             p = np;
  185.         }
  186.     }
  187.     
  188.     _lwrite(hf, NULL, 0); // truncate
  189.     
  190.     _lclose(hf);
  191.     free(buf);
  192.     
  193.     bWrite = TRUE;
  194. }
  195.  
  196. /*-------------------------------------------
  197.   WM_TIMER message
  198. ---------------------------------------------*/
  199. void OnStopTimer(HWND hwnd, int id)
  200. {
  201.     int i;
  202.     
  203.     if(!m_pTimerRun) return;
  204.     
  205.     for(i = 0; i < m_numTimerRun; i++)
  206.     {
  207.         if((m_pTimerRun + i)->id == id)
  208.         {
  209.             DeleteRunningTimer(hwnd, i);
  210.             break;
  211.         }
  212.     }
  213. }
  214.  
  215. /*-------------------------------------------
  216.   execute timer
  217. ---------------------------------------------*/
  218. void DoTimer(HWND hwnd, int index)
  219. {
  220.     PTIMERSTRUCT pTS;
  221.     char command[MAX_PATH + 10];
  222.     HWND hwndMain;
  223.     
  224.     if(!m_pTimerRun ||
  225.         !(0 <= index && index < m_numTimerRun)) return;
  226.     
  227.     pTS = m_pTimerRun + index;
  228.     
  229.     command[0] = 0;
  230.     if(pTS->bRepeat) strcpy(command, "-1 ");
  231.     strcat(command, pTS->fname);
  232.     hwndMain = GetTClockMainWindow();
  233.     if(hwndMain)
  234.         SendStringToOther(hwndMain, hwnd, command, COPYDATA_SOUND);
  235.     
  236.     if(pTS->bBlink)
  237.         PostMessage(g_hwndClock, CLOCKM_BLINK, 0, 0);
  238.     
  239.     DeleteRunningTimer(hwnd, index);
  240. }
  241.  
  242. /*-------------------------------------------
  243.   delete an executed timer from array
  244. ---------------------------------------------*/
  245. void DeleteRunningTimer(HWND hwnd, int index)
  246. {
  247.     PTIMERSTRUCT pTS;
  248.     
  249.     if(!m_pTimerRun) return;
  250.     
  251.     pTS = m_pTimerRun + index;
  252.     
  253.     if(pTS->bDisp)
  254.     {
  255.         int nCopyData;
  256.         if(pTS->nDispType == 0)
  257.             nCopyData = COPYDATA_DISP1;
  258.         else if(pTS->nDispType == 2)
  259.             nCopyData = COPYDATA_USTR0 + pTS->nUserStr;
  260.         else
  261.             nCopyData = COPYDATA_CAT1;
  262.         SendStringToOtherW(g_hwndClock, hwnd, L"", nCopyData);
  263.     }
  264.     
  265.     if(m_numTimerRun > 1)
  266.     {
  267.         PTIMERSTRUCT pNew;
  268.         pNew = DelTimerStruct(m_pTimerRun, m_numTimerRun, index);
  269.         m_numTimerRun--;
  270.         free(m_pTimerRun);
  271.         m_pTimerRun = pNew;
  272.     }
  273.     else
  274.     {
  275.         m_numTimerRun = 0;
  276.         free(m_pTimerRun);
  277.         m_pTimerRun = NULL;
  278.     }
  279.     
  280.     OnRequestMenu(hwnd, TRUE);
  281.     
  282.     if(m_numTimerRun == 0 && !(g_hDlg && IsWindow(g_hDlg)))
  283.         PostMessage(hwnd, WM_CLOSE, 0, 0);
  284. }
  285.